<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>24.3. shlex — Simple lexical analysis &mdash; Python 3.4.3 documentation</title>
    
    <link rel="stylesheet" href="../_static/pydoctheme.css" type="text/css" />
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '../',
        VERSION:     '3.4.3',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="../_static/jquery.js"></script>
    <script type="text/javascript" src="../_static/underscore.js"></script>
    <script type="text/javascript" src="../_static/doctools.js"></script>
    <script type="text/javascript" src="../_static/sidebar.js"></script>
    <link rel="search" type="application/opensearchdescription+xml"
          title="Search within Python 3.4.3 documentation"
          href="../_static/opensearch.xml"/>
    <link rel="author" title="About these documents" href="../about.html" />
    <link rel="copyright" title="Copyright" href="../copyright.html" />
    <link rel="top" title="Python 3.4.3 documentation" href="../index.html" />
    <link rel="up" title="24. Program Frameworks" href="frameworks.html" />
    <link rel="next" title="25. Graphical User Interfaces with Tk" href="tk.html" />
    <link rel="prev" title="24.2. cmd — Support for line-oriented command interpreters" href="cmd.html" />
    <link rel="shortcut icon" type="image/png" href="../_static/py.png" />
    <script type="text/javascript" src="../_static/copybutton.js"></script>
    <script type="text/javascript" src="../_static/version_switch.js"></script>
    
 

  </head>
  <body>  
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="tk.html" title="25. Graphical User Interfaces with Tk"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="cmd.html" title="24.2. cmd — Support for line-oriented command interpreters"
             accesskey="P">previous</a> |</li>
        <li><img src="../_static/py.png" alt=""
                 style="vertical-align: middle; margin-top: -1px"/></li>
        <li><a href="https://www.python.org/">Python</a> &raquo;</li>
        <li>
          <span class="version_switcher_placeholder">3.4.3</span>
          <a href="../index.html">Documentation</a> &raquo;
        </li>

          <li><a href="index.html" >The Python Standard Library</a> &raquo;</li>
          <li><a href="frameworks.html" accesskey="U">24. Program Frameworks</a> &raquo;</li> 
      </ul>
    </div>    

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="module-shlex">
<span id="shlex-simple-lexical-analysis"></span><h1>24.3. <a class="reference internal" href="#module-shlex" title="shlex: Simple lexical analysis for Unix shell-like languages."><tt class="xref py py-mod docutils literal"><span class="pre">shlex</span></tt></a> &#8212; Simple lexical analysis<a class="headerlink" href="#module-shlex" title="Permalink to this headline">¶</a></h1>
<p><strong>Source code:</strong> <a class="reference external" href="https://hg.python.org/cpython/file/3.4/Lib/shlex.py">Lib/shlex.py</a></p>
<hr class="docutils" />
<p>The <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> class makes it easy to write lexical analyzers for
simple syntaxes resembling that of the Unix shell.  This will often be useful
for writing minilanguages, (for example, in run control files for Python
applications) or for parsing quoted strings.</p>
<p>The <a class="reference internal" href="#module-shlex" title="shlex: Simple lexical analysis for Unix shell-like languages."><tt class="xref py py-mod docutils literal"><span class="pre">shlex</span></tt></a> module defines the following functions:</p>
<dl class="function">
<dt id="shlex.split">
<tt class="descclassname">shlex.</tt><tt class="descname">split</tt><big>(</big><em>s</em>, <em>comments=False</em>, <em>posix=True</em><big>)</big><a class="headerlink" href="#shlex.split" title="Permalink to this definition">¶</a></dt>
<dd><p>Split the string <em>s</em> using shell-like syntax. If <em>comments</em> is <a class="reference internal" href="constants.html#False" title="False"><tt class="xref py py-const docutils literal"><span class="pre">False</span></tt></a>
(the default), the parsing of comments in the given string will be disabled
(setting the <a class="reference internal" href="#shlex.shlex.commenters" title="shlex.shlex.commenters"><tt class="xref py py-attr docutils literal"><span class="pre">commenters</span></tt></a> attribute of the
<a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> instance to the empty string).  This function operates
in POSIX mode by default, but uses non-POSIX mode if the <em>posix</em> argument is
false.</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">Since the <a class="reference internal" href="#shlex.split" title="shlex.split"><tt class="xref py py-func docutils literal"><span class="pre">split()</span></tt></a> function instantiates a <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a>
instance, passing <tt class="docutils literal"><span class="pre">None</span></tt> for <em>s</em> will read the string to split from
standard input.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="shlex.quote">
<tt class="descclassname">shlex.</tt><tt class="descname">quote</tt><big>(</big><em>s</em><big>)</big><a class="headerlink" href="#shlex.quote" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a shell-escaped version of the string <em>s</em>.  The returned value is a
string that can safely be used as one token in a shell command line, for
cases where you cannot use a list.</p>
<p>This idiom would be unsafe:</p>
<div class="highlight-python3"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">filename</span> <span class="o">=</span> <span class="s">&#39;somefile; rm -rf ~&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">command</span> <span class="o">=</span> <span class="s">&#39;ls -l {}&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">command</span><span class="p">)</span>  <span class="c"># executed by a shell: boom!</span>
<span class="go">ls -l somefile; rm -rf ~</span>
</pre></div>
</div>
<p><a class="reference internal" href="#shlex.quote" title="shlex.quote"><tt class="xref py py-func docutils literal"><span class="pre">quote()</span></tt></a> lets you plug the security hole:</p>
<div class="highlight-python3"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">command</span> <span class="o">=</span> <span class="s">&#39;ls -l {}&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">quote</span><span class="p">(</span><span class="n">filename</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">command</span><span class="p">)</span>
<span class="go">ls -l &#39;somefile; rm -rf ~&#39;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">remote_command</span> <span class="o">=</span> <span class="s">&#39;ssh home {}&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">quote</span><span class="p">(</span><span class="n">command</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">remote_command</span><span class="p">)</span>
<span class="go">ssh home &#39;ls -l &#39;&quot;&#39;&quot;&#39;somefile; rm -rf ~&#39;&quot;&#39;&quot;&#39;&#39;</span>
</pre></div>
</div>
<p>The quoting is compatible with UNIX shells and with <a class="reference internal" href="#shlex.split" title="shlex.split"><tt class="xref py py-func docutils literal"><span class="pre">split()</span></tt></a>:</p>
<div class="highlight-python3"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">remote_command</span> <span class="o">=</span> <span class="n">split</span><span class="p">(</span><span class="n">remote_command</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">remote_command</span>
<span class="go">[&#39;ssh&#39;, &#39;home&#39;, &quot;ls -l &#39;somefile; rm -rf ~&#39;&quot;]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">command</span> <span class="o">=</span> <span class="n">split</span><span class="p">(</span><span class="n">remote_command</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">command</span>
<span class="go">[&#39;ls&#39;, &#39;-l&#39;, &#39;somefile; rm -rf ~&#39;]</span>
</pre></div>
</div>
<div class="versionadded">
<p><span class="versionmodified">New in version 3.3.</span></p>
</div>
</dd></dl>

<p>The <a class="reference internal" href="#module-shlex" title="shlex: Simple lexical analysis for Unix shell-like languages."><tt class="xref py py-mod docutils literal"><span class="pre">shlex</span></tt></a> module defines the following class:</p>
<dl class="class">
<dt id="shlex.shlex">
<em class="property">class </em><tt class="descclassname">shlex.</tt><tt class="descname">shlex</tt><big>(</big><em>instream=None</em>, <em>infile=None</em>, <em>posix=False</em><big>)</big><a class="headerlink" href="#shlex.shlex" title="Permalink to this definition">¶</a></dt>
<dd><p>A <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> instance or subclass instance is a lexical analyzer
object.  The initialization argument, if present, specifies where to read
characters from. It must be a file-/stream-like object with
<a class="reference internal" href="io.html#io.TextIOBase.read" title="io.TextIOBase.read"><tt class="xref py py-meth docutils literal"><span class="pre">read()</span></tt></a> and <a class="reference internal" href="io.html#io.TextIOBase.readline" title="io.TextIOBase.readline"><tt class="xref py py-meth docutils literal"><span class="pre">readline()</span></tt></a> methods, or
a string.  If no argument is given, input will be taken from <tt class="docutils literal"><span class="pre">sys.stdin</span></tt>.
The second optional argument is a filename string, which sets the initial
value of the <a class="reference internal" href="#shlex.shlex.infile" title="shlex.shlex.infile"><tt class="xref py py-attr docutils literal"><span class="pre">infile</span></tt></a> attribute.  If the <em>instream</em>
argument is omitted or equal to <tt class="docutils literal"><span class="pre">sys.stdin</span></tt>, this second argument
defaults to &#8220;stdin&#8221;.  The <em>posix</em> argument defines the operational mode:
when <em>posix</em> is not true (default), the <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> instance will
operate in compatibility mode.  When operating in POSIX mode,
<a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> will try to be as close as possible to the POSIX shell
parsing rules.</p>
</dd></dl>

<div class="admonition seealso">
<p class="first admonition-title">See also</p>
<dl class="last docutils">
<dt>Module <a class="reference internal" href="configparser.html#module-configparser" title="configparser: Configuration file parser."><tt class="xref py py-mod docutils literal"><span class="pre">configparser</span></tt></a></dt>
<dd>Parser for configuration files similar to the Windows <tt class="file docutils literal"><span class="pre">.ini</span></tt> files.</dd>
</dl>
</div>
<div class="section" id="shlex-objects">
<span id="id1"></span><h2>24.3.1. shlex Objects<a class="headerlink" href="#shlex-objects" title="Permalink to this headline">¶</a></h2>
<p>A <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> instance has the following methods:</p>
<dl class="method">
<dt id="shlex.shlex.get_token">
<tt class="descclassname">shlex.</tt><tt class="descname">get_token</tt><big>(</big><big>)</big><a class="headerlink" href="#shlex.shlex.get_token" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a token.  If tokens have been stacked using <a class="reference internal" href="#shlex.shlex.push_token" title="shlex.shlex.push_token"><tt class="xref py py-meth docutils literal"><span class="pre">push_token()</span></tt></a>, pop a
token off the stack.  Otherwise, read one from the input stream.  If reading
encounters an immediate end-of-file, <a class="reference internal" href="#shlex.shlex.eof" title="shlex.shlex.eof"><tt class="xref py py-attr docutils literal"><span class="pre">eof</span></tt></a> is returned (the empty
string (<tt class="docutils literal"><span class="pre">''</span></tt>) in non-POSIX mode, and <tt class="docutils literal"><span class="pre">None</span></tt> in POSIX mode).</p>
</dd></dl>

<dl class="method">
<dt id="shlex.shlex.push_token">
<tt class="descclassname">shlex.</tt><tt class="descname">push_token</tt><big>(</big><em>str</em><big>)</big><a class="headerlink" href="#shlex.shlex.push_token" title="Permalink to this definition">¶</a></dt>
<dd><p>Push the argument onto the token stack.</p>
</dd></dl>

<dl class="method">
<dt id="shlex.shlex.read_token">
<tt class="descclassname">shlex.</tt><tt class="descname">read_token</tt><big>(</big><big>)</big><a class="headerlink" href="#shlex.shlex.read_token" title="Permalink to this definition">¶</a></dt>
<dd><p>Read a raw token.  Ignore the pushback stack, and do not interpret source
requests.  (This is not ordinarily a useful entry point, and is documented here
only for the sake of completeness.)</p>
</dd></dl>

<dl class="method">
<dt id="shlex.shlex.sourcehook">
<tt class="descclassname">shlex.</tt><tt class="descname">sourcehook</tt><big>(</big><em>filename</em><big>)</big><a class="headerlink" href="#shlex.shlex.sourcehook" title="Permalink to this definition">¶</a></dt>
<dd><p>When <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> detects a source request (see <a class="reference internal" href="#shlex.shlex.source" title="shlex.shlex.source"><tt class="xref py py-attr docutils literal"><span class="pre">source</span></tt></a>
below) this method is given the following token as argument, and expected
to return a tuple consisting of a filename and an open file-like object.</p>
<p>Normally, this method first strips any quotes off the argument.  If the result
is an absolute pathname, or there was no previous source request in effect, or
the previous source was a stream (such as <tt class="docutils literal"><span class="pre">sys.stdin</span></tt>), the result is left
alone.  Otherwise, if the result is a relative pathname, the directory part of
the name of the file immediately before it on the source inclusion stack is
prepended (this behavior is like the way the C preprocessor handles <tt class="docutils literal"><span class="pre">#include</span>
<span class="pre">&quot;file.h&quot;</span></tt>).</p>
<p>The result of the manipulations is treated as a filename, and returned as the
first component of the tuple, with <a class="reference internal" href="functions.html#open" title="open"><tt class="xref py py-func docutils literal"><span class="pre">open()</span></tt></a> called on it to yield the second
component. (Note: this is the reverse of the order of arguments in instance
initialization!)</p>
<p>This hook is exposed so that you can use it to implement directory search paths,
addition of file extensions, and other namespace hacks. There is no
corresponding &#8216;close&#8217; hook, but a shlex instance will call the
<a class="reference internal" href="io.html#io.IOBase.close" title="io.IOBase.close"><tt class="xref py py-meth docutils literal"><span class="pre">close()</span></tt></a> method of the sourced input stream when it returns
EOF.</p>
<p>For more explicit control of source stacking, use the <a class="reference internal" href="#shlex.shlex.push_source" title="shlex.shlex.push_source"><tt class="xref py py-meth docutils literal"><span class="pre">push_source()</span></tt></a> and
<a class="reference internal" href="#shlex.shlex.pop_source" title="shlex.shlex.pop_source"><tt class="xref py py-meth docutils literal"><span class="pre">pop_source()</span></tt></a> methods.</p>
</dd></dl>

<dl class="method">
<dt id="shlex.shlex.push_source">
<tt class="descclassname">shlex.</tt><tt class="descname">push_source</tt><big>(</big><em>newstream</em>, <em>newfile=None</em><big>)</big><a class="headerlink" href="#shlex.shlex.push_source" title="Permalink to this definition">¶</a></dt>
<dd><p>Push an input source stream onto the input stack.  If the filename argument is
specified it will later be available for use in error messages.  This is the
same method used internally by the <a class="reference internal" href="#shlex.shlex.sourcehook" title="shlex.shlex.sourcehook"><tt class="xref py py-meth docutils literal"><span class="pre">sourcehook()</span></tt></a> method.</p>
</dd></dl>

<dl class="method">
<dt id="shlex.shlex.pop_source">
<tt class="descclassname">shlex.</tt><tt class="descname">pop_source</tt><big>(</big><big>)</big><a class="headerlink" href="#shlex.shlex.pop_source" title="Permalink to this definition">¶</a></dt>
<dd><p>Pop the last-pushed input source from the input stack. This is the same method
used internally when the lexer reaches EOF on a stacked input stream.</p>
</dd></dl>

<dl class="method">
<dt id="shlex.shlex.error_leader">
<tt class="descclassname">shlex.</tt><tt class="descname">error_leader</tt><big>(</big><em>infile=None</em>, <em>lineno=None</em><big>)</big><a class="headerlink" href="#shlex.shlex.error_leader" title="Permalink to this definition">¶</a></dt>
<dd><p>This method generates an error message leader in the format of a Unix C compiler
error label; the format is <tt class="docutils literal"><span class="pre">'&quot;%s&quot;,</span> <span class="pre">line</span> <span class="pre">%d:</span> <span class="pre">'</span></tt>, where the <tt class="docutils literal"><span class="pre">%s</span></tt> is replaced
with the name of the current source file and the <tt class="docutils literal"><span class="pre">%d</span></tt> with the current input
line number (the optional arguments can be used to override these).</p>
<p>This convenience is provided to encourage <a class="reference internal" href="#module-shlex" title="shlex: Simple lexical analysis for Unix shell-like languages."><tt class="xref py py-mod docutils literal"><span class="pre">shlex</span></tt></a> users to generate error
messages in the standard, parseable format understood by Emacs and other Unix
tools.</p>
</dd></dl>

<p>Instances of <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> subclasses have some public instance
variables which either control lexical analysis or can be used for debugging:</p>
<dl class="attribute">
<dt id="shlex.shlex.commenters">
<tt class="descclassname">shlex.</tt><tt class="descname">commenters</tt><a class="headerlink" href="#shlex.shlex.commenters" title="Permalink to this definition">¶</a></dt>
<dd><p>The string of characters that are recognized as comment beginners. All
characters from the comment beginner to end of line are ignored. Includes just
<tt class="docutils literal"><span class="pre">'#'</span></tt> by default.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.wordchars">
<tt class="descclassname">shlex.</tt><tt class="descname">wordchars</tt><a class="headerlink" href="#shlex.shlex.wordchars" title="Permalink to this definition">¶</a></dt>
<dd><p>The string of characters that will accumulate into multi-character tokens.  By
default, includes all ASCII alphanumerics and underscore.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.whitespace">
<tt class="descclassname">shlex.</tt><tt class="descname">whitespace</tt><a class="headerlink" href="#shlex.shlex.whitespace" title="Permalink to this definition">¶</a></dt>
<dd><p>Characters that will be considered whitespace and skipped.  Whitespace bounds
tokens.  By default, includes space, tab, linefeed and carriage-return.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.escape">
<tt class="descclassname">shlex.</tt><tt class="descname">escape</tt><a class="headerlink" href="#shlex.shlex.escape" title="Permalink to this definition">¶</a></dt>
<dd><p>Characters that will be considered as escape. This will be only used in POSIX
mode, and includes just <tt class="docutils literal"><span class="pre">'\'</span></tt> by default.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.quotes">
<tt class="descclassname">shlex.</tt><tt class="descname">quotes</tt><a class="headerlink" href="#shlex.shlex.quotes" title="Permalink to this definition">¶</a></dt>
<dd><p>Characters that will be considered string quotes.  The token accumulates until
the same quote is encountered again (thus, different quote types protect each
other as in the shell.)  By default, includes ASCII single and double quotes.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.escapedquotes">
<tt class="descclassname">shlex.</tt><tt class="descname">escapedquotes</tt><a class="headerlink" href="#shlex.shlex.escapedquotes" title="Permalink to this definition">¶</a></dt>
<dd><p>Characters in <a class="reference internal" href="#shlex.shlex.quotes" title="shlex.shlex.quotes"><tt class="xref py py-attr docutils literal"><span class="pre">quotes</span></tt></a> that will interpret escape characters defined in
<a class="reference internal" href="#shlex.shlex.escape" title="shlex.shlex.escape"><tt class="xref py py-attr docutils literal"><span class="pre">escape</span></tt></a>.  This is only used in POSIX mode, and includes just <tt class="docutils literal"><span class="pre">'&quot;'</span></tt> by
default.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.whitespace_split">
<tt class="descclassname">shlex.</tt><tt class="descname">whitespace_split</tt><a class="headerlink" href="#shlex.shlex.whitespace_split" title="Permalink to this definition">¶</a></dt>
<dd><p>If <tt class="docutils literal"><span class="pre">True</span></tt>, tokens will only be split in whitespaces. This is useful, for
example, for parsing command lines with <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a>, getting
tokens in a similar way to shell arguments.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.infile">
<tt class="descclassname">shlex.</tt><tt class="descname">infile</tt><a class="headerlink" href="#shlex.shlex.infile" title="Permalink to this definition">¶</a></dt>
<dd><p>The name of the current input file, as initially set at class instantiation time
or stacked by later source requests.  It may be useful to examine this when
constructing error messages.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.instream">
<tt class="descclassname">shlex.</tt><tt class="descname">instream</tt><a class="headerlink" href="#shlex.shlex.instream" title="Permalink to this definition">¶</a></dt>
<dd><p>The input stream from which this <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> instance is reading
characters.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.source">
<tt class="descclassname">shlex.</tt><tt class="descname">source</tt><a class="headerlink" href="#shlex.shlex.source" title="Permalink to this definition">¶</a></dt>
<dd><p>This attribute is <tt class="docutils literal"><span class="pre">None</span></tt> by default.  If you assign a string to it, that
string will be recognized as a lexical-level inclusion request similar to the
<tt class="docutils literal"><span class="pre">source</span></tt> keyword in various shells.  That is, the immediately following token
will opened as a filename and input taken from that stream until EOF, at which
point the <a class="reference internal" href="io.html#io.IOBase.close" title="io.IOBase.close"><tt class="xref py py-meth docutils literal"><span class="pre">close()</span></tt></a> method of that stream will be called and
the input source will again become the original input stream.  Source
requests may be stacked any number of levels deep.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.debug">
<tt class="descclassname">shlex.</tt><tt class="descname">debug</tt><a class="headerlink" href="#shlex.shlex.debug" title="Permalink to this definition">¶</a></dt>
<dd><p>If this attribute is numeric and <tt class="docutils literal"><span class="pre">1</span></tt> or more, a <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a>
instance will print verbose progress output on its behavior.  If you need
to use this, you can read the module source code to learn the details.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.lineno">
<tt class="descclassname">shlex.</tt><tt class="descname">lineno</tt><a class="headerlink" href="#shlex.shlex.lineno" title="Permalink to this definition">¶</a></dt>
<dd><p>Source line number (count of newlines seen so far plus one).</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.token">
<tt class="descclassname">shlex.</tt><tt class="descname">token</tt><a class="headerlink" href="#shlex.shlex.token" title="Permalink to this definition">¶</a></dt>
<dd><p>The token buffer.  It may be useful to examine this when catching exceptions.</p>
</dd></dl>

<dl class="attribute">
<dt id="shlex.shlex.eof">
<tt class="descclassname">shlex.</tt><tt class="descname">eof</tt><a class="headerlink" href="#shlex.shlex.eof" title="Permalink to this definition">¶</a></dt>
<dd><p>Token used to determine end of file. This will be set to the empty string
(<tt class="docutils literal"><span class="pre">''</span></tt>), in non-POSIX mode, and to <tt class="docutils literal"><span class="pre">None</span></tt> in POSIX mode.</p>
</dd></dl>

</div>
<div class="section" id="parsing-rules">
<span id="shlex-parsing-rules"></span><h2>24.3.2. Parsing Rules<a class="headerlink" href="#parsing-rules" title="Permalink to this headline">¶</a></h2>
<p>When operating in non-POSIX mode, <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> will try to obey to the
following rules.</p>
<ul class="simple">
<li>Quote characters are not recognized within words (<tt class="docutils literal"><span class="pre">Do&quot;Not&quot;Separate</span></tt> is
parsed as the single word <tt class="docutils literal"><span class="pre">Do&quot;Not&quot;Separate</span></tt>);</li>
<li>Escape characters are not recognized;</li>
<li>Enclosing characters in quotes preserve the literal value of all characters
within the quotes;</li>
<li>Closing quotes separate words (<tt class="docutils literal"><span class="pre">&quot;Do&quot;Separate</span></tt> is parsed as <tt class="docutils literal"><span class="pre">&quot;Do&quot;</span></tt> and
<tt class="docutils literal"><span class="pre">Separate</span></tt>);</li>
<li>If <a class="reference internal" href="#shlex.shlex.whitespace_split" title="shlex.shlex.whitespace_split"><tt class="xref py py-attr docutils literal"><span class="pre">whitespace_split</span></tt></a> is <tt class="docutils literal"><span class="pre">False</span></tt>, any character not
declared to be a word character, whitespace, or a quote will be returned as
a single-character token. If it is <tt class="docutils literal"><span class="pre">True</span></tt>, <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> will only
split words in whitespaces;</li>
<li>EOF is signaled with an empty string (<tt class="docutils literal"><span class="pre">''</span></tt>);</li>
<li>It&#8217;s not possible to parse empty strings, even if quoted.</li>
</ul>
<p>When operating in POSIX mode, <a class="reference internal" href="#shlex.shlex" title="shlex.shlex"><tt class="xref py py-class docutils literal"><span class="pre">shlex</span></tt></a> will try to obey to the
following parsing rules.</p>
<ul class="simple">
<li>Quotes are stripped out, and do not separate words (<tt class="docutils literal"><span class="pre">&quot;Do&quot;Not&quot;Separate&quot;</span></tt> is
parsed as the single word <tt class="docutils literal"><span class="pre">DoNotSeparate</span></tt>);</li>
<li>Non-quoted escape characters (e.g. <tt class="docutils literal"><span class="pre">'\'</span></tt>) preserve the literal value of the
next character that follows;</li>
<li>Enclosing characters in quotes which are not part of
<a class="reference internal" href="#shlex.shlex.escapedquotes" title="shlex.shlex.escapedquotes"><tt class="xref py py-attr docutils literal"><span class="pre">escapedquotes</span></tt></a> (e.g. <tt class="docutils literal"><span class="pre">&quot;'&quot;</span></tt>) preserve the literal value
of all characters within the quotes;</li>
<li>Enclosing characters in quotes which are part of
<a class="reference internal" href="#shlex.shlex.escapedquotes" title="shlex.shlex.escapedquotes"><tt class="xref py py-attr docutils literal"><span class="pre">escapedquotes</span></tt></a> (e.g. <tt class="docutils literal"><span class="pre">'&quot;'</span></tt>) preserves the literal value
of all characters within the quotes, with the exception of the characters
mentioned in <a class="reference internal" href="#shlex.shlex.escape" title="shlex.shlex.escape"><tt class="xref py py-attr docutils literal"><span class="pre">escape</span></tt></a>.  The escape characters retain its
special meaning only when followed by the quote in use, or the escape
character itself. Otherwise the escape character will be considered a
normal character.</li>
<li>EOF is signaled with a <a class="reference internal" href="constants.html#None" title="None"><tt class="xref py py-const docutils literal"><span class="pre">None</span></tt></a> value;</li>
<li>Quoted empty strings (<tt class="docutils literal"><span class="pre">''</span></tt>) are allowed.</li>
</ul>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
  <h3><a href="../contents.html">Table Of Contents</a></h3>
  <ul>
<li><a class="reference internal" href="#">24.3. <tt class="docutils literal"><span class="pre">shlex</span></tt> &#8212; Simple lexical analysis</a><ul>
<li><a class="reference internal" href="#shlex-objects">24.3.1. shlex Objects</a></li>
<li><a class="reference internal" href="#parsing-rules">24.3.2. Parsing Rules</a></li>
</ul>
</li>
</ul>

  <h4>Previous topic</h4>
  <p class="topless"><a href="cmd.html"
                        title="previous chapter">24.2. <tt class="docutils literal"><span class="pre">cmd</span></tt> &#8212; Support for line-oriented command interpreters</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="tk.html"
                        title="next chapter">25. Graphical User Interfaces with Tk</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
  <li><a href="../bugs.html">Report a Bug</a></li>
  <li><a href="../_sources/library/shlex.txt"
         rel="nofollow">Show Source</a></li>
</ul>

<div id="searchbox" style="display: none">
  <h3>Quick search</h3>
    <form class="search" action="../search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
    <p class="searchtip" style="font-size: 90%">
    Enter search terms or a module, class or function name.
    </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>  
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="tk.html" title="25. Graphical User Interfaces with Tk"
             >next</a> |</li>
        <li class="right" >
          <a href="cmd.html" title="24.2. cmd — Support for line-oriented command interpreters"
             >previous</a> |</li>
        <li><img src="../_static/py.png" alt=""
                 style="vertical-align: middle; margin-top: -1px"/></li>
        <li><a href="https://www.python.org/">Python</a> &raquo;</li>
        <li>
          <span class="version_switcher_placeholder">3.4.3</span>
          <a href="../index.html">Documentation</a> &raquo;
        </li>

          <li><a href="index.html" >The Python Standard Library</a> &raquo;</li>
          <li><a href="frameworks.html" >24. Program Frameworks</a> &raquo;</li> 
      </ul>
    </div>  
    <div class="footer">
    &copy; <a href="../copyright.html">Copyright</a> 1990-2015, Python Software Foundation.
    <br />
    The Python Software Foundation is a non-profit corporation.
    <a href="https://www.python.org/psf/donations/">Please donate.</a>
    <br />
    Last updated on Feb 26, 2015.
    <a href="../bugs.html">Found a bug</a>?
    <br />
    Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.2.3.
    </div>

  </body>
</html>